package com.revzone.demo001.service.impl;
import com.revzone.demo001.Enum.EnumOperationLog;
import com.revzone.demo001.Enum.EnumTypeValue;
import com.revzone.demo001.config.OperationLog;
import com.revzone.demo001.entity.Result;
import com.revzone.demo001.entity.UserRole;
import com.revzone.demo001.entity.UserRoleDTO;
import com.revzone.demo001.mapper.RoleMapper_old;
import com.revzone.demo001.mapper.UserRoleMapper;
import com.revzone.demo001.service.RoleService_old;
import org.springframework.security.crypto.password.PasswordEncoder; // Spring Security 提供的密码编码器
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.revzone.demo001.entity.User;
import com.revzone.demo001.service.UserService_old;
import com.revzone.demo001.mapper.UserMapper_old;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;

/**
* @author Admin
* @description 针对表【user】的数据库操作Service实现
* @createDate 2025-06-25 10:01:25
*/
@Service
public class UserServiceImpl_old extends ServiceImpl<UserMapper_old, User> implements UserService_old {

//    private static final Logger logger = LoggerFactory.getLogger(UserService.class);

    @Autowired
    private UserMapper_old userMapper; // 用于从数据库查询用户信息

    @Autowired
    private PasswordEncoder passwordEncoder;
    @Autowired
    private RoleService_old roleService;
    @Autowired
    private RoleMapper_old roleMapper;
    @Autowired
    private UserRoleMapper userroleMapper;


    /**
     * 认证用户身份。
     *
     * @param username    用户名
     * @param rawPassword 用户输入的原始密码（明文）
     * @return 认证成功的 User 对象，如果认证失败则返回 null。
     */
    @OperationLog(value = EnumTypeValue.USER_PERMISSIONS, description = EnumOperationLog.USER_LOGIN_MSG)
    public User authenticate(String username, String rawPassword) {
        if (username == null || username.trim().isEmpty() || rawPassword == null || rawPassword.isEmpty()) {
            return null; // 用户名或密码为空，直接拒绝
        }

        // 1. 根据用户名从数据库查找用户
        User user = userMapper.findByUsername(username);

        // 2. 检查用户是否存在
        if (user == null) {
//            logger.warn("认证失败：用户 [{}] 不存在。", username);
            return null; // 用户不存在
        }

        // 3. 比对密码
        // passwordEncoder.matches(rawPassword, encodedPassword) 会将 rawPassword 进行编码，然后与 encodedPassword 比对
        if (passwordEncoder.matches(rawPassword, user.getPassword())) {
//            logger.info("认证成功：用户 [{}]。", username);
            // 认证成功，返回用户对象 (可以根据需要清除密码敏感信息再返回)
            user.setPassword(null); // 返回前清除密码，避免敏感信息泄露
            return user;
        } else {
//            logger.warn("认证失败：用户 [{}] 密码不匹配。", username);
            return null; // 密码不匹配
        }
    }

    @OperationLog(value = EnumTypeValue.USER_PERMISSIONS, description = EnumOperationLog.USER_LOGIN_MSG)
    // ... 其他用户相关的业务方法，例如注册用户：
    public User registerUser(User user) {
        if (userMapper.findByUsername(user.getUser_name()) != null) {
            throw new RuntimeException("用户已存在！");
        }
        User newUser = new User();
        newUser.setUser_name(user.getUser_name());
        newUser.setPassword(passwordEncoder.encode(user.getPassword()));
        newUser.setNick_name(user.getNick_name());
        newUser.setSex(user.getSex());
        newUser.setEmail(user.getEmail());
        newUser.setPhone(user.getPhone());
        newUser.setCreate_date(LocalDateTime.now());
        newUser.setUpdate_date(LocalDateTime.now());
        newUser.setStatus(0);
        userMapper.insert(newUser);


        // userDao.save(newUser); // 保存到数据库
//        logger.info("用户 [{}] 注册成功。", username);
        return newUser;
    }

    // 根据用户名获取用户信息的辅助方法
    public User getUserByUsername(String username) {
        return userMapper.findByUsername(username);
    }

    // 获取用户权限码的辅助方法（示例）
    public List<String> getUserPermissionCodes(Long userId) {
        // 实际中可能需要通过用户ID -> 角色ID -> 权限ID/Code 的多表查询
        // 示例：简单返回一些权限码
        if (userId == 1L) { // 假设ID为1是管理员
            return Arrays.asList("user:list", "user:add", "user:edit", "user:delete", "role:list", "role:add", "log:view");
        } else {
            return Arrays.asList("user:list");
        }
    }

    // 页面数据传入，增加用户
    @Transactional
    public Result saveUserWithRole(UserRoleDTO userRoleDTO) {
        try {
            // 1. 创建用户对象并保存
            User user = new User();
            user.setId(userRoleDTO.getId());
            user.setUser_name(userRoleDTO.getUser_name());
            user.setNick_name(userRoleDTO.getNick_name());
            user.setPhone(userRoleDTO.getPhone());
            user.setEmail(userRoleDTO.getEmail());
            user.setSex(userRoleDTO.getSex());
            user.setStatus(userRoleDTO.getStatus());
            user.setRemarks(userRoleDTO.getRemarks());
            user.setUpdate_date(LocalDateTime.now());
            user.setCreate_date(LocalDateTime.now());
            user.setPassword(passwordEncoder.encode(userRoleDTO.getPassword()));

            // 设置其他字段...
            userMapper.insert(user);

            // 2. 获取刚插入的用户ID
            Integer userId = user.getId();

            // 3. 根据角色名查询角色ID
            Integer roleId = roleMapper.findRoleIdByName(userRoleDTO.getRole_name());
            if (roleId == null) {
                // 如果角色不存在，可能需要抛出异常或者进行其他错误处理
                throw new RuntimeException("Role '" + userRoleDTO.getRole_name() + "' not found.");
            }

            // 4. 插入用户角色关系
            UserRole userrole = new UserRole(userId, roleId);
            userroleMapper.insert(userrole);
            // 如果所有步骤都成功，返回成功结果
            return Result.success("success");

        } catch (Exception e) { // 统一捕获所有异常
            // 在生产环境中，应该使用日志框架记录异常，而不是直接打印堆栈
            e.printStackTrace(); // 仅用于开发调试
            return Result.error("Failure"); // 根据你的需求返回通用的“Failure”
        }
    }

    // 更新用户及其角色关系
    @Transactional
    public Result updateUserWithRole(UserRoleDTO userRoleDTO) {
        try{
            // 1. 验证用户是否存在
            User existingUser = userMapper.selectById(userRoleDTO.getId());
            if (existingUser == null) {
                throw new RuntimeException("用户不存在: " + userRoleDTO.getId());
            }

            // 2. 更新用户基本信息
            User user = convertToUser(userRoleDTO);
            userMapper.updateById(user);

            // 3. 获取新角色ID
            String roleName = userRoleDTO.getRole_name();
            Integer newRoleId = roleMapper.findRoleIdByName(roleName);
            if (newRoleId == null) {
                throw new RuntimeException("角色不存在: " + userRoleDTO.getRole_name());
            }

            // 4. 删除旧角色关系
            Integer userId = user.getId();
            userroleMapper.deleteByUserId(userId);

            // 5. 创建并保存新角色关系
            UserRole newUserRole = new UserRole(userRoleDTO.getId(), newRoleId);
            userroleMapper.updateById(newUserRole);

            return Result.success("success");
        } catch (Exception e) { // 统一捕获所有异常
            // 在生产环境中，应该使用日志框架记录异常，而不是直接打印堆栈
            e.printStackTrace(); // 仅用于开发调试
            return Result.error("更新用户失败"); // 根据你的需求返回通用的“Failure”
        }
    }


    // 删除用户及其角色关系
    @Transactional
    public Result deleteUserWithRole(Integer userId) {
        try{
            // 1. 验证用户是否存在
            User user = userMapper.selectById(userId);
            if (user == null) {
                throw new RuntimeException("用户不存在: " + userId);
            }

            // 2. 删除用户角色关系（先删关联）
            userroleMapper.deleteByUserId(userId);

            // 3. 删除用户
            userMapper.deleteById(userId);
            return Result.success("success");
        } catch (Exception e) { // 统一捕获所有异常
            // 在生产环境中，应该使用日志框架记录异常，而不是直接打印堆栈
            e.printStackTrace(); // 仅用于开发调试
            return Result.error("删除用户失败");
        }
    }

    // 公共转换方法
    private User convertToUser(UserRoleDTO userRoleDTO) {
        User user = new User();
        user.setUser_name(userRoleDTO.getUser_name());
        user.setNick_name(userRoleDTO.getNick_name());
        user.setPhone(userRoleDTO.getPhone());
        user.setEmail(userRoleDTO.getEmail());
        user.setSex(userRoleDTO.getSex());
        user.setStatus(userRoleDTO.getStatus());
        user.setRemarks(userRoleDTO.getRemarks());
        user.setUpdate_date(LocalDateTime.now());  // 更新修改时间
        return user;
    }
    public Result resetPassword(Integer id, String password ) {
        User user = userMapper.selectById(id);
        user.setPassword(passwordEncoder.encode(password));
        int affectedRows = userMapper.updateById(user);

        // 5. 判断更新是否成功
        if (affectedRows > 0) {
            return Result.success("密码修改成功");
        } else {
            // 虽然userMapper.updateById返回0通常意味着ID不存在或数据未改变，
            // 但因为我们之前已经检查了user!=null，所以这里更可能是数据库操作层面的问题
            return Result.error("修改密码失败，可能是数据库操作问题或数据未更改");
        }
    }

}



